﻿using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using System.Web.Security;
using Teenusekiht . EnumIds;

namespace Teenusekiht
{
    public class TeenuseKlass
    {
        /// <summary>
        /// Uue kohviku lisamine
        /// </summary>
        /// <param name="nimi">Kohviku nimi</param>
        /// <param name="piltAsukoht">Kohviku asukoha pildi aadress</param>
        /// <param name="kirjeldus">Kohviku kirjeldus</param>
        /// <returns></returns>
        public bool LisaKohvik(string nimi, string piltAsukoht, string kirjeldus, string omanik, string rakenduseNimi)
        {
            bool onnestus = false;
            LinqtoSqlDataContext kont = new LinqtoSqlDataContext();
            Kohvik uusKohvik = new Kohvik();
            uusKohvik.Name = nimi;
            uusKohvik.Pilt_asukoht = piltAsukoht;
            uusKohvik.Kirjeldus = kirjeldus;
            uusKohvik.Kinnitatud = true;

            try
            {
                kont.Kohviks.InsertOnSubmit(uusKohvik);
                kont.SubmitChanges();
                onnestus = true;
            }
            catch { }
            int id = 0;
            var kohvikud = from x in kont.Kohviks where x.Name.Equals(nimi) select x.Kohvik_ID;
            foreach (var kohvikID in kohvikud)
            {
                id = kohvikID;
            }
            
            int id2 = 0;
            var kasutajad = from x in kont.Kasutajas where x.Nimi.Equals(omanik) select x.Kasutaja_ID;
            foreach (var kasID in kasutajad)
            {
                id2 = kasID;
            }

            Kohviku_kasutaja kas = new Kohviku_kasutaja();
            kas.Kasutaja_ID = id2;
            kas.Kohvik_ID = id;
            kas.Roll_ID = 1;
            try
            {
                kont.Kohviku_kasutajas.InsertOnSubmit(kas);
                kont.SubmitChanges();
            }
            catch (Exception)
            {
            }

            kont.Dispose();
            LisaParingAB(rakenduseNimi, "LisaKohvik");
            return onnestus;
        }

        /// <summary>
        /// Muudab kohviku kirjelduse
        /// </summary>
        /// <param name="kohvikId">Vastava kohviku ID</param>
        /// <param name="kirjeldus">Uus kirjeldus kohvikule</param>
        /// <returns>õnnestumisel true, vastasel juhul false</returns>
        public bool MuudaKohvikuKirjeldus(int kohvikId, string kirjeldus, String rakenduseNimi)
        {
            bool result = true ;
            LinqtoSqlDataContext kont = new LinqtoSqlDataContext();
            try {
                Kohvik kohvik = (from t1 in kont.Kohviks
                                 where t1.Kohvik_ID == kohvikId
                                 select t1).SingleOrDefault();
                if (kohvik != null) {
                    kohvik.Kirjeldus = kirjeldus ;
                    kont.SubmitChanges(); }
                  else {
                    result = false ; } }
              catch {
                result = false ; }
            kont.Dispose();
            LisaParingAB(rakenduseNimi, "MuudaKohvikuKirjeldus");
            return (result);
        }

        /// <summary>
        /// Tagastab kõigi kohvikute arvu
        /// </summary>
        /// <returns>kõigi kohvikute arv</returns>
        public int KohvikuteArv(String rakenduseNimi)
        {
            LinqtoSqlDataContext kont = new LinqtoSqlDataContext();
            int arv = kont.Kohviks.Count();
            kont.Dispose();
            LisaParingAB(rakenduseNimi, "KohvikuteArv");
            return arv;
        }

        /// <summary>
        /// Tagastab kõigi kohvikute nimed massiivina
        /// </summary>
        /// <returns>massiiv kohvikute nimedest</returns>
        public string[] KohvikuteNimed(String rakenduseNimi)
        {
            LinqtoSqlDataContext kont = new LinqtoSqlDataContext();
            string[] kohvikud = (from x in kont.Kohviks select x.Name).ToArray();
            kont.Dispose();
            LisaParingAB(rakenduseNimi, "KohvikuteNimed");
            return kohvikud;
        }

        /// <summary>
        /// Tagastab menüü järgi kas inimesel oleks õigust seda muuta
        /// </summary>
        /// <param name="menyy_ID">menüü ID</param>
        /// <param name=" kasutaja_ID">kasutaja ID</param>
        /// <returns>tagastab true , kui ei õnnestu, tagastab false</returns>
        public bool TagastabMenuuMuutujad(int menyy_ID, int? kasutaja_ID, String rakenduseNimi)
        {
            List<SiteKasutaja> lubatudInimesed = new List<SiteKasutaja>();
            LinqtoSqlDataContext kont = new LinqtoSqlDataContext();
            bool vastus = false;

            //  var kohvikud = from x in kont.Kohviku_kasutajas
            //                 where x.Kasutaja_ID == Omaniku_ID && x.Roll.Nimetus == "Omanik"
            //                 select x.Kohvik_ID;

            var kohvikud = from x in kont.Kohviku_Menyys
                           where x.Menyy_ID == menyy_ID
                           select x.Kohvik;

            foreach (Kohvik uusKohvik in kohvikud)
            {
                int id = uusKohvik.Kohvik_ID;

                var menyypomod = (from x in kont.Kohviku_kasutajas
                                  where x.Kohvik_ID == id && (x.Roll.Nimetus == "Omanik" || x.Roll.Nimetus == "Müüja")
                                  select x.Kasutaja).ToList();

                foreach (Kasutaja vastusKasutaja in menyypomod)
                {
                    bool lubatud = true;
                    foreach (SiteKasutaja kontrollitav in lubatudInimesed)
                    {
                        if (kontrollitav.Kasutaja_ID == vastusKasutaja.Kasutaja_ID)
                            lubatud = false;
                    }

                    if (lubatud)
                    {
                        lubatudInimesed.Add(new SiteKasutaja()
                        {
                            Kasutaja_ID = vastusKasutaja.Kasutaja_ID,
                            Nimi = vastusKasutaja.Nimi,
                            Kasutaja_liik_ID = vastusKasutaja.Kasutaja_liik_ID,
                            Kasutaja_Liik_Nimi = vastusKasutaja.Kasutaja_liik.Nimetus
                        });
                    }
                }
            }
            
            vastus = lubatudInimesed.Any(kasutaja => kasutaja.Kasutaja_ID == kasutaja_ID);
            //foreach (SiteKasutaja kontrollitav in lubatudInimesed) 
            //    if (kontrollitav.Kasutaja_ID == kasutaja_ID) 
            //    { vastus = true; break; }

            kont.Dispose();
            LisaParingAB(rakenduseNimi, "TagastabMenuuMuutujad");
            return vastus;
        }

        /// <summary>
        /// Tagastab antud kohviku ID järgi kohviku nime
        /// </summary>
        /// <param name="kohvikID">kohviku ID</param>
        /// <returns>kohviku nimi</returns>
        public string KohvikuNimiIdJargi(int kohvikID, String rakenduseNimi)
        {
            LinqtoSqlDataContext kont = new LinqtoSqlDataContext();
            var nimed = from x in kont.Kohviks where x.Kohvik_ID == kohvikID select x.Name;
            string nimi = (nimed.Count() != 0) ? nimed.First() : "";
            kont.Dispose();
            LisaParingAB(rakenduseNimi, "KohvikuNimiIdJargi");
            return nimi;
        }

        /// <summary>
        /// Tagastab kõik kirjed tabelist Kasutaja
        /// </summary>
        /// <returns>kõik kirjed tabelist Kasutaja</returns>
        public SiteKasutaja[] AnnaKoikSaidiKasutajad(String rakenduseNimi)
        {
            LinqtoSqlDataContext kont = new LinqtoSqlDataContext();
            var sitekasutajad = (from x in kont.Kasutajas
                                 select new SiteKasutaja()
                                 {
                                     Kasutaja_ID = x.Kasutaja_ID,
                                     Kasutaja_liik_ID = x.Kasutaja_liik_ID,
                                     Nimi = x.Nimi,
                                     Kasutaja_Liik_Nimi = x.Kasutaja_liik.Nimetus
                                 }).ToArray();
            kont.Dispose();
            LisaParingAB(rakenduseNimi, "AnnaKoikSaidiKasutajad");
            return sitekasutajad;
        }

        /// <summary>
        /// Tagastab antud omaniku ID järgi kõik omaniku kohvikute ID-d massiivina
        /// </summary>
        /// <param name="Omaniku_ID">omaniku ID</param>
        /// <returns>kõik antud omaniku ID järgi kohvikute ID-d</returns>
        public int[] AnnaKoikOmanikuKohvikud(int Omaniku_ID, String rakenduseNimi)
        {
            LinqtoSqlDataContext kont = new LinqtoSqlDataContext();
            var kohvikud = (from x in kont.Kohviku_kasutajas
                            where x.Kasutaja_ID == Omaniku_ID && x.Roll.Nimetus == "Omanik"
                            select x.Kohvik_ID).ToArray();
            kont.Dispose();
            LisaParingAB(rakenduseNimi, "AnnaKoikOmanikuKohvikud");
            return kohvikud;
        }

        /// <summary>
        /// Tagastab antud kohviku ID järgi kõik kohviku kasutajad massiivina
        /// </summary>
        /// <param name="kohviku_ID">kohviku ID</param>
        /// <returns>kohviku kasutajad</returns>
        public SiteKasutaja[] AnnaKoikKohvikuKasutajad(int kohviku_ID, String rakenduseNimi)
        {
            LinqtoSqlDataContext kont = new LinqtoSqlDataContext();
            var sitekasutajad = (from x in kont.Kohviku_kasutajas
                                 where x.Kohvik_ID == kohviku_ID
                                 select new SiteKasutaja()
                                 {
                                     Kasutaja_ID = x.Kasutaja.Kasutaja_ID,
                                     Kasutaja_liik_ID = x.Kasutaja.Kasutaja_liik_ID,
                                     Nimi = x.Kasutaja.Nimi,
                                     Kasutaja_Liik_Nimi = x.Kasutaja.Kasutaja_liik.Nimetus, // ja selle kohvikuga seotud roll
                                     KohvikuKasutajaRollid = new KohvikuKasutajaRoll[1] { new KohvikuKasutajaRoll { Kohvik_ID = kohviku_ID, Roll_ID = x.Roll_ID, Roll_Nimetus = x.Roll.Nimetus } }
                                 }).ToArray();
            kont.Dispose();
            LisaParingAB(rakenduseNimi, "AnnaKoikKohvikuKasutajad");
            return sitekasutajad;
        }

        /// <summary>
        /// Tagastab antud kasutaja ID järgi kõik kasutaja rollid kõikides kohvikutes
        /// </summary>
        /// <param name="kasutaja_ID">kasutaja ID</param>
        /// <returns>kasutaja ID järgi kohviku kasutaja kõik rollid, ebaõnnestumise korral null</returns>
        public KohvikuKasutajaRoll[] KasutajaKohvikuRollid(int kasutaja_ID, String rakenduseNimi)
        {
            LinqtoSqlDataContext kont = new LinqtoSqlDataContext();
            var result = (from x in kont.Kohviku_kasutajas
                          where x.Kasutaja_ID == kasutaja_ID
                          select new KohvikuKasutajaRoll()
                          {
                              Kohvik_ID = x.Kohvik_ID,
                              Roll_ID = x.Roll_ID
                          }).ToArray();

            kont.Dispose();
            LisaParingAB(rakenduseNimi, "KasutajaKohvikuRollid");
            return result;
        }

        /// <summary>
        /// Tagastab andmebaasi kõik võimalikud site kasutaja rollid (id-d ja nimed), kohviku_id jääb tühjaks
        /// </summary>
        /// <returns>massiivi andmebaasis eksisteerivatest erinevatest võimalikest site kasutaja rollidest</returns>
        public KohvikuKasutajaRoll[] KoikLubatudKohvikuRollid(String rakenduseNimi)
        {
            LinqtoSqlDataContext kont = new LinqtoSqlDataContext();
            var result = (from x in kont.Rolls
                          select new KohvikuKasutajaRoll()
                          {
                              Roll_Nimetus = x.Nimetus,
                              Roll_ID = x.Roll_ID
                          }).ToArray();
            kont.Dispose();
            LisaParingAB(rakenduseNimi, "KoikLubatudKohvikuRollid");
            return result;
        }

        /// <summary>
        /// Tagastab andmebaasi kõik võimalikud kohviku kasutaja rollid (id-d ja nimed), muud andmed jäävad tühjaks
        /// </summary>
        /// <returns>massiivi andmebaasis eksisteerivatest erinevatest võimalikest kohviku kasutaja rollidest</returns>
        public SiteKasutaja[] KoikLubatudSaidiKasutajaTyybid(String rakenduseNimi)
        {
            LinqtoSqlDataContext kont = new LinqtoSqlDataContext();
            var result = (from x in kont.Kasutaja_liiks
                          select new SiteKasutaja()
                          {
                              Kasutaja_liik_ID = x.Kasutaja_liik_ID,
                              Kasutaja_Liik_Nimi = x.Nimetus
                          }).ToArray();
            kont.Dispose();
            LisaParingAB(rakenduseNimi, "KoikLubatudSaidiKasutajaTyybid");
            return result;
        }

        /// <summary>
        /// Tagastab antud kasutaja ID ja kohviku ID järgi kohviku kasutaja rolli ID
        /// </summary>
        /// <param name="kohviku_kasutaja_ID">kasutaja ID</param>
        /// <param name="kohviku_ID">kohviku ID</param>
        /// <returns>kasutaja ID ja kohviku ID järgi kohviku kasutaja rolli ID, ebaõnnestumise korral null</returns>
        public int? KohvikuKasutajaLiikID(int kohviku_kasutaja_ID, int kohviku_ID, String rakenduseNimi)
        {
            LinqtoSqlDataContext kont = new LinqtoSqlDataContext();
            var result = from x in kont.Kohviku_kasutajas
                         where x.Kohviku_kasutaja_ID == kohviku_kasutaja_ID && x.Kohvik_ID == kohviku_ID
                         select x.Roll_ID;
            int? id = (result.Count() != 0) ? (int?)result.First() : null;
            kont.Dispose();
            LisaParingAB(rakenduseNimi, "KohvikuKasutajaLiikID");
            return id;
        }

        /// <summary>
        /// Muudab antud kasutaja ID ja kohviku ID järgi kasutaja rolli kohvikus, kui rolli pole, siis tekitatakse uus
        /// </summary>
        /// <param name="site_kasutaja_ID">kasutaja ID</param>
        /// <param name="kohviku_ID">kohviku ID</param>
        /// <param name="rollID">uus rolli ID</param>
        /// <returns>õnnestumise korral true, vastasel juhul false</returns>
        public bool MuudaKohvikuKasutajaRoll(int site_kasutaja_ID, int kohviku_ID, int rollID, String rakenduseNimi)
        {
            bool result = true;
            LinqtoSqlDataContext kont = new LinqtoSqlDataContext();
            var query = from kasutaja in kont.Kohviku_kasutajas
                        where kasutaja.Kasutaja_ID == site_kasutaja_ID && kasutaja.Kohvik_ID == kohviku_ID
                        select kasutaja;
            if (query.Count() != 0)
            {
                foreach (Kohviku_kasutaja kasutaja in query)
                {
                    kasutaja.Roll_ID = rollID;
                }
            }
            else
            {
                Kohviku_kasutaja uusKohvikuKasutaja = new Kohviku_kasutaja();
                uusKohvikuKasutaja.Kasutaja_ID = site_kasutaja_ID;
                uusKohvikuKasutaja.Kohvik_ID = kohviku_ID;
                uusKohvikuKasutaja.Roll_ID = rollID;
                kont.Kohviku_kasutajas.InsertOnSubmit(uusKohvikuKasutaja);
            }
            try { kont.SubmitChanges(); }
            catch { result = false; }
            kont.Dispose();
            LisaParingAB(rakenduseNimi, "MuudaKohvikuKasutajaRoll");
            return result;
        }

        /// <summary>
        /// Kustutab antud kasutaja ID järgi kasutaja tabelis Kasutaja
        /// </summary>
        /// <param name="site_kasutaja_ID">kasutaja ID</param>
        /// <returns>õnnestumise korral true, vastasel juhul false</returns>
        public bool KustutaSaidiKasutaja(int site_kasutaja_ID, String rakenduseNimi)
        {
            bool result = true;
            LinqtoSqlDataContext kont = new LinqtoSqlDataContext();
            var query = from kasutaja in kont.Kasutajas
                        where kasutaja.Kasutaja_ID == site_kasutaja_ID
                        select kasutaja;
            foreach (var item in query)
            {
                kont.Kasutajas.DeleteOnSubmit(item);
            }
            
            try { kont.SubmitChanges(); }
            catch { result = false; }
            kont.Dispose();
            LisaParingAB(rakenduseNimi, "KustutaSaidiKasutaja");
            return result;
        }


        /// <summary>
        /// Muudab antud kasutaja ID järgi kasutaja liigi tabelis Kasutaja
        /// </summary>
        /// <param name="site_kasutaja_ID">kasutaja ID</param>
        /// <param name="liik">liigi ID</param>
        /// <returns>õnnestumise korral true, vastasel juhul false</returns>
        public bool MuudaSaidiKasutajaLiik(int site_kasutaja_ID, int liik, String rakenduseNimi)
        {
            bool result = true;
            LinqtoSqlDataContext kont = new LinqtoSqlDataContext();
            var query = from kasutaja in kont.Kasutajas
                        where kasutaja.Kasutaja_ID == site_kasutaja_ID
                        select kasutaja;
            foreach (Kasutaja kasutaja in query)
            {
                kasutaja.Kasutaja_liik_ID = liik;
            }
            try { kont.SubmitChanges(); }
            catch { result = false; }
            kont.Dispose();
            LisaParingAB(rakenduseNimi, "MuudaSaidiKasutajaLiik");
            return result;
        }

        /// <summary>
        /// Tagastab antud kasutaja ID järgi kasutaja liigi ID
        /// </summary>
        /// <param name="site_kasutaja_ID">kasutaja ID</param>
        /// <returns>õnnestumise korral kasutaja liik ID, vastasel juhul null</returns>
        public int? SaidiKasutajaLiikID(int site_kasutaja_ID, String rakenduseNimi)
        {
            LinqtoSqlDataContext kont = new LinqtoSqlDataContext();
            var result = from x in kont.Kasutajas where x.Kasutaja_ID == site_kasutaja_ID select x.Kasutaja_liik_ID;
            int? id = (result.Count() != 0) ? result.First() : null;
            kont.Dispose();
            LisaParingAB(rakenduseNimi, "SaidiKasutajaLiikID");
            return id;
        }

        /// <summary>
        /// Tagastab antud kasutaja ID järgi kasutaja liigi nimetuse
        /// </summary>
        /// <param name="site_kasutaja_ID">kasutaja ID</param>
        /// <returns>kasutaja ID järgi kasutaja liigi nimetuse</returns>
        public string SaidiKasutajaLiik(int site_kasutaja_ID, String rakenduseNimi)
        {
            LinqtoSqlDataContext kont = new LinqtoSqlDataContext();
            var result = from x in kont.Kasutajas
                         where x.Kasutaja_ID == site_kasutaja_ID
                         select x.Kasutaja_liik.Nimetus;
            string vastus = (result.Count() != 0) ? result.First() : "";
            kont.Dispose();
            LisaParingAB(rakenduseNimi, "SaidiKasutajaLiik");
            return vastus;
        }

        /// <summary>
        /// Tagastab kohviku ID järgi kohviku tänaste või mitte tänaste menüüde ID-de massiivi
        /// </summary>
        /// <param name="kohviku_ID">antud kohviku ID</param>
        /// <param name="today">kas tagastada tänased või mitte tänased menüüd</param>
        /// <returns>kohviku menüüde ID-de massiivi</returns>
        public int[] MenuuKohvikuIdJargi(int kohviku_ID, bool isToday, String rakenduseNimi)
        {
            LinqtoSqlDataContext kont = new LinqtoSqlDataContext();
            int[] menyyd = (from x in kont.Kohviku_Menyys
                            where x.Kohvik_ID == kohviku_ID && x.TODAY_S_MENY == isToday
                            select x.Menyy_ID).ToArray();
            kont.Dispose();
            LisaParingAB(rakenduseNimi, "MenuuKohvikuIdJargi");
            return menyyd;
        }

        /// <summary>
        /// muudab antud müügiartikli tabelis Myygiartikkel
        /// </summary>
        /// <param name="menyyItem">müügiartikli ID</param>
        /// <returns>info õnnestumise kohta või veateade</returns>
        public string VahetaMenuuArtiklit(MenyyItem menyyItem, String rakenduseNimi)
        {
            string result = "menyyitemi muutmine 6nnestus";
            LinqtoSqlDataContext kont = new LinqtoSqlDataContext();
            var query = from myygiartikkel in kont.Myygiartikkels
                        where myygiartikkel.Myygiartikkel_ID == menyyItem.Id
                        select myygiartikkel;
            foreach (Myygiartikkel myygiartikkel in query)
            {
                myygiartikkel.Hind = menyyItem.Hind;
                myygiartikkel.Nimetus = menyyItem.MyygiartikliNimi;
                myygiartikkel.Kaup_ID = menyyItem.Kaup_ID;
                myygiartikkel.Kommentaar = menyyItem.Kommentaar;
            }
            try { kont.SubmitChanges(); }
            catch (Exception e) { result = e.ToString(); }
            kont.Dispose();
            LisaParingAB(rakenduseNimi, "VahetaMenuuArtiklit");
            return result;
        }

        /// <summary>
        /// Seob menyyartikli ja menyy
        /// </summary>
        /// <param name="item_ID">Menyyartikli ID</param>
        /// <param name="menyy_ID">menyy ID</param>
        /// <returns>tagastab seose ID</returns>
        public int? LisaArtikkelMenuuse(int item_ID, int menyy_ID, String rakenduseNimi)
        {
            int? result;
            LinqtoSqlDataContext kont = new LinqtoSqlDataContext();
            Myygiartikkel_menyy newSeos = new Myygiartikkel_menyy();
            newSeos.Menyy_ID = menyy_ID;
            newSeos.Myygiartikkel_ID = item_ID;
            kont.Myygiartikkel_menyys.InsertOnSubmit(newSeos);
            try
            {
                kont.SubmitChanges();
                result = (int)newSeos.Myygiartikkel_menyys_ID;
            }
            catch { result = null; }
            kont.Dispose();
            LisaParingAB(rakenduseNimi, "LisaArtikkelMenuuse");
            return result;
        }

        /// <summary>
        /// Kustutab menüü ja kohviku seose
        /// </summary>
        /// <param name="kohvik_ID">kohviku ID</param>
        /// <param name="menyy_ID">menüü ID</param>
        /// <returns>tagastab true, kui ei õnnestu, tagastab false</returns>
        public bool KustutaMenuuJaKohvikuSeos(int kohvik_ID, int menyy_ID, String rakenduseNimi)
        {
            bool result = true;
            LinqtoSqlDataContext kont = new LinqtoSqlDataContext();
            var deleteItems = from items in kont.Kohviku_Menyys
                              where items.Kohvik_ID == kohvik_ID && items.Menyy_ID == menyy_ID
                              select items;
            foreach (var item in deleteItems)
            {
                kont.Kohviku_Menyys.DeleteOnSubmit(item);
            }
            try { kont.SubmitChanges(); }
            catch { result = false; }
            kont.Dispose();
            LisaParingAB(rakenduseNimi, "KustutaMenuuJaKohvikuSeos");
            return result;
        }

        /// <summary>
        /// Seob menüü ja kohviku
        /// </summary>
        /// <param name="kohvik_ID">kohviku ID</param>
        /// <param name="menyy_ID">menüü ID</param>
        /// <returns>tagastab uue seose ID, kui ei õnnestu, tagastab nulli</returns>
        public int? LisaKohvikuleMenuu(int kohvik_ID, int menyy_ID, String rakenduseNimi)
        {
            int? result;
            LinqtoSqlDataContext kont = new LinqtoSqlDataContext();
            Kohviku_Menyy newSeos = new Kohviku_Menyy();
            newSeos.Menyy_ID = menyy_ID;
            newSeos.Kohvik_ID = kohvik_ID;
            kont.Kohviku_Menyys.InsertOnSubmit(newSeos);
            try
            {
                kont.SubmitChanges();
                result = (int?)newSeos.Kohviku_Menyy_ID;
            }
            catch { result = null; }
            kont.Dispose();
            LisaParingAB(rakenduseNimi, "LisaKohvikuleMenuu");
            return result;
        }

        /// <summary>
        /// Teeb uue menüü, seob selle kohvikuga, kui kohviku ID on parameetrina kaasa antud
        /// </summary>
        /// <param name="kohvik_ID">kohviku ID</param>
        /// <param name="kohvik_ID">menüü nimi</param>
        /// <returns>tagastab uue menüü ID, kui ei õnnestu, tagastab nulli</returns>
        public int? LisaUusMenuu(int? kohvik_ID, string menyyNimi, String rakenduseNimi)
        {
            int? result;
            LinqtoSqlDataContext kont = new LinqtoSqlDataContext();
            Menyy newItem = new Menyy() { Nimetus = menyyNimi };
            kont.Menyys.InsertOnSubmit(newItem);
            if (kohvik_ID != null)
            {
                Kohviku_Menyy newSeos = new Kohviku_Menyy();
                newSeos.Menyy = newItem;
                newSeos.Kohvik_ID = (int)kohvik_ID;
            }
            try
            {
                kont.SubmitChanges();
                result = (int?)newItem.Menyy_ID;
            }
            catch { result = null; }
            kont.Dispose();
            LisaParingAB(rakenduseNimi, "LisaUusMenuu");
            return result;
        }

        /// <summary>
        /// Tagastab menyyde ID-d mis pole seotud kohvikuga, mille ID on kohvikID
        /// </summary>
        /// <param name="kohvikID">kohviku ID</param>
        /// <returns></returns>
        public int[] AnnaMenyydMidaPoleKohvikul(int kohvikID, String rakenduseNimi)
        {
            LinqtoSqlDataContext cont = new LinqtoSqlDataContext();
            int[] menyyIDd = cont.Menyys.Select(m => m.Menyy_ID).ToArray();
            int[] kohvikuMenyyIDd = (from x in cont.Kohviku_Menyys
                                     where x.Kohvik_ID == kohvikID
                                     select x.Menyy_ID).ToArray();
            cont.Dispose();
            LisaParingAB(rakenduseNimi, "AnnaMenyydMidaPoleKohvikul");
            return menyyIDd.Where(id => !kohvikuMenyyIDd.Contains(id)).ToArray();
        }

        /// <summary>
        /// Muudab kohviku menyy TODAY_S_MENY oleku (teeb inversiooni)
        /// </summary>
        /// <param name="kohvikID">kohviku ID</param>
        /// <param name="menuID">menyy ID</param>
        /// <returns>true kui muutmine 6nnestus</returns>
        public bool MuudaKohvikuMenyyTodayOlek(int kohvikID, int menuID, String rakenduseNimi)
        {
            LinqtoSqlDataContext cont = new LinqtoSqlDataContext();
            bool success = true;
            var kohvikuMenu = from x in cont.Kohviku_Menyys
                              where x.Kohvik_ID == kohvikID && x.Menyy_ID == menuID
                              select x;
            foreach (var item in kohvikuMenu)
            {
                item.TODAY_S_MENY = !item.TODAY_S_MENY;
            }
            try { cont.SubmitChanges(); }
            catch { success = false; }
            cont.Dispose();
            LisaParingAB(rakenduseNimi, "MuudaKohvikuMenyyTodayOlek");
            return success;
        }

        /// <summary>
        /// Sisestab antud müügiartikli menüüsse, mille ID on menyy_id
        /// </summary>
        /// <param name="menyyItem">müügiartikkel</param>
        /// <param name="menyy_id">menüü ID</param>
        /// <returns>õnnestumisel true, vastasel juhul false</returns>
        public bool LisaMenuuArtikkelMenuuse(MenyyItem menyyItem, int? menyy_id, String rakenduseNimi)
        {
            bool result = true;
            LinqtoSqlDataContext kont = new LinqtoSqlDataContext();
            Myygiartikkel newItem = new Myygiartikkel();
            newItem.Hind = menyyItem.Hind;
            newItem.Kaup_ID = menyyItem.Kaup_ID;
            newItem.Kommentaar = menyyItem.Kommentaar;
            newItem.Nimetus = menyyItem.MyygiartikliNimi;
            kont.Myygiartikkels.InsertOnSubmit(newItem);
            if (menyy_id != null)
            {
                Myygiartikkel_menyy newSeos = new Myygiartikkel_menyy();
                newSeos.Myygiartikkel = newItem;
                newSeos.Menyy_ID = (int)menyy_id;
            }
            try { kont.SubmitChanges(); }
            catch { result = false; }
            kont.Dispose();
            LisaParingAB(rakenduseNimi, "LisaMenuuArtikkelMenuuse");
            return result;
        }

        /// <summary>
        /// Kustutab myygiartikliID ja menyyID j2rgi myygiartikli menyyst
        /// </summary>
        /// <param name="menyyItemID"></param>
        /// <param name="menuID"></param>
        /// <returns>õnnestumisel true, vastasel juhul false</returns>
        public bool KustutaMenuuArtikkel(int[] menyyItemIDs, String rakenduseNimi)
        {
            bool result = true;
            LinqtoSqlDataContext kont = new LinqtoSqlDataContext();
            var deleteItems = from items in kont.Myygiartikkel_menyys
                              where menyyItemIDs.Contains(items.Myygiartikkel_ID)
                              select items;
            foreach (var item in deleteItems)
            {
                kont.Myygiartikkel_menyys.DeleteOnSubmit(item);
            }
            try { kont.SubmitChanges(); }
            catch { result = false; }
            kont.Dispose();
            LisaParingAB(rakenduseNimi, "KustutaMenuuArtikkel");
            return result;
        }


       /// <summary>
       /// muudab soodustuse tabelis Soodustus, kui soodustust ei eksisteeri/leita, siis tekitatakse uus soodustus
       /// </summary>
       /// <param name="soodus"></param>
       /// <param name="rakenduseNimi"></param>
       /// <returns></returns>
        public string MuudaVoiLisaSoodustust(SoodustusType soodus, String rakenduseNimi)
        {
            string result = "soodustuse muutmine 6nnestus";
            LinqtoSqlDataContext kont = new LinqtoSqlDataContext();
            var query = from soodustus in kont.Soodustus
                        where soodustus.Soodustus_ID == soodus.Soodustus_ID
                        select soodustus;

            if (query.Count() != 0)
            {
                foreach (Soodustus soodustus in query)
                {
                    soodustus.Nimi = soodus.SoodustuseNimi;
                    soodustus.Kommentaar = soodus.Kommentaar;
                    soodustus.Hind = soodus.Hind;
                    soodustus.Soodustuse_Kordaja = soodus.Kordaja;
                }
            }
            else
            {

                Soodustus soodustus = new Soodustus();
                soodustus.Nimi = soodus.SoodustuseNimi;
                soodustus.Kommentaar = soodus.Kommentaar;
                soodustus.Hind = soodus.Hind;
                soodustus.Soodustuse_Kordaja = soodus.Kordaja;
                kont.Soodustus.InsertOnSubmit(soodustus);
            }

            try { kont.SubmitChanges(); }
            catch (Exception e) { result = e.ToString(); }
            kont.Dispose();
            LisaParingAB(rakenduseNimi, "MuudaVoiLisaSoodustust");
            return result;
        }


        /// <summary>
        /// Tagastab müügiartiklite soodustused müügiartiklite ID-de järgi
        /// </summary>
        /// <param name="myygiArtiklid">müügiartiklite ID-d</param>
        /// <param name="rakenduseNimi"></param>
        /// <returns>müügiartiklite soodustused müügiartiklite ID-de järgi</returns>
        public SoodustusType[] AnnaSoodustused(int[] myygiArtiklid, String rakenduseNimi)
        {
            LinqtoSqlDataContext cont = new LinqtoSqlDataContext();
            var soodustused = (from t1 in cont.Myygiartikli_soodustus
                              join t2 in cont.Soodustus on t1.Soodustus_ID equals t2.Soodustus_ID
                              where myygiArtiklid.Contains((int)t1.Myygiartikkel_ID)
                              select new SoodustusType
                              {
                                  Soodustus_ID = t1.Soodustus_ID,
                                  SoodustuseNimi = t2.Nimi,
                                  MyygiArtikkel_ID = t1.Myygiartikkel_ID,
                                  Kordaja = t2.Soodustuse_Kordaja,
                                  Hind = t2.Hind,
                                  Kommentaar = t2.Kommentaar
                              }).ToArray();
            cont.Dispose();
            LisaParingAB(rakenduseNimi, "AnnaSoodustused");
            return soodustused;
        }

        /// <summary>
        /// Annab kohviku ID alusel kohviku soodustused.
        /// </summary>
        /// <param name="kohvikuID">kohviku ID</param>
        /// <param name="rakenduseNimi"></param>
        /// <returns>kohviku ID alusel kohviku soodustused</returns>
        public SoodustusType[] AnnaKohvikuSoodustused(int kohvikuID, String rakenduseNimi)
        {
            LinqtoSqlDataContext cont = new LinqtoSqlDataContext();
            var menyyd = (from x in cont.Kohviku_Menyys
                         where x.Kohvik_ID == kohvikuID
                         select x.Menyy_ID).ToArray();
            var myygiArtiklid = (from x in cont.Myygiartikkel_menyys
                                where menyyd.Contains(x.Menyy_ID)
                                select x.Myygiartikkel_ID).ToArray();
            var soodustusIDd = (from x in cont.Myygiartikli_soodustus
                                where myygiArtiklid.Contains((int)x.Myygiartikkel_ID)
                                select x.Soodustus.Soodustus_ID).ToArray();
            var soodustused = (from x in cont.Soodustus
                              where soodustusIDd.Contains(x.Soodustus_ID)
                              select new SoodustusType
                              {
                                  Soodustus_ID = x.Soodustus_ID,
                                  SoodustuseNimi = x.Nimi,
                                  Kordaja = x.Soodustuse_Kordaja,
                                  Hind = x.Hind,
                                  Kommentaar = x.Kommentaar
                              }).ToArray();

            cont.Dispose();
            LisaParingAB(rakenduseNimi, "AnnaKohvikuSoodustused");
            return soodustused;
        }

        /// <summary>
        /// Tagastab menüü ID järgi menüüs olevad müügiartiklid
        /// </summary>
        /// <param name="menyy_ID">menüü ID</param>
        /// <returns>menüü müügiartiklid massiivina</returns>
        public MenyyItem[] TagastaMenuuArtiklid(int menyy_ID, String rakenduseNimi)
        {
            LinqtoSqlDataContext kont = new LinqtoSqlDataContext();
            var artiklidMenyys = (from x in kont.Myygiartikkel_menyys
                                  where x.Menyy_ID == menyy_ID
                                  select new MenyyItem()
                                  {
                                      Hind = x.Myygiartikkel.Hind,
                                      Kaup_ID = x.Myygiartikkel.Kaup_ID,
                                      MyygiartikliNimi = x.Myygiartikkel.Nimetus,
                                      Kommentaar = x.Myygiartikkel.Kommentaar,
                                      Id = x.Myygiartikkel.Myygiartikkel_ID
                                  }).ToArray();
            kont.Dispose();
            LisaParingAB(rakenduseNimi, "TagastaMenuuArtiklid");
            return artiklidMenyys;
        }

        /// <summary>
        /// Tagastab menüü ID järgi menüü nimetuse
        /// </summary>
        /// <param name="menuID">menüü ID</param>
        /// <returns>menüü nimetus</returns>
        public string MenuuNimetus(int menuID, String rakenduseNimi)
        {
            LinqtoSqlDataContext kont = new LinqtoSqlDataContext();
            var nimed = from x in kont.Menyys where x.Menyy_ID == menuID select x.Nimetus;
            string nimi = (nimed.Count() != 0) ? nimed.First() : "";
            kont.Dispose();
            LisaParingAB(rakenduseNimi, "MenuuNimetus");
            return nimi;
        }

        /// <summary>
        /// Tagastab myygiartiklid, mis pole veel menyys, kus on juba myygiartiklid, mille IDd on antud massiivis
        /// </summary>
        /// <param name="olemasMyygiArtikliIDs">myygiartiklidte IDd mis on juba menyys olemas</param>
        /// <returns>myygiartiklid, mis pole veel menyys, kus on juba myygiartiklid, mille IDd on antud massiivis</returns>
        public List<MyygiartikkelType> AnnaMuugiartiklidMidaMenuusPole(int[] olemasMyygiArtikliIDs, String rakenduseNimi)
        {
            LinqtoSqlDataContext cont = new LinqtoSqlDataContext();
            List<MyygiartikkelType> list = new List<MyygiartikkelType>();
            var res = (from x in cont.Myygiartikkels
                       where ! olemasMyygiArtikliIDs.Contains(x.Myygiartikkel_ID)
                       select new { x.Myygiartikkel_ID, x.Nimetus }).ToList();
            foreach (var a in res)
            {
                list.Add(new MyygiartikkelType() { MyygiArtikkelID = a.Myygiartikkel_ID, Nimetus = a.Nimetus });
            }
            cont.Dispose();
            LisaParingAB(rakenduseNimi, "AnnaMuugiartiklidMidaMenuusPole");
            return list;
        }

        /// <summary>
        /// Tagastab kõigi menüüde nimetused tabelis Menyy
        /// </summary>
        /// <returns>kõigi menüüde nimetused tabelis Menyy</returns>
        public string[] AnnaMenuuNimed(String rakenduseNimi)
        {
            LinqtoSqlDataContext cont = new LinqtoSqlDataContext();
            string[] nimed = (from x in cont.Menyys select x.Nimetus).ToArray();
            cont.Dispose();
            LisaParingAB(rakenduseNimi, "AnnaMenuuNimed");
            return nimed;
        }

        /// <summary>
        /// Tagastab kõik kohvikute kirjed tabelist Kohvik
        /// </summary>
        /// <returns>list Kohvikutest</returns>
        public List<KohvikType> Kohvikud(String rakenduseNimi) 
        {
            LinqtoSqlDataContext kont = new LinqtoSqlDataContext();
            var cafes = (from x in kont.Kohviks select new { x.Name, x.Kohvik_ID, x.Kirjeldus }).ToList();
            List<KohvikType> uusList = new List<KohvikType>();
            foreach (var cafe in cafes)
            {
                KohvikType uusKohvikType = new KohvikType();
                uusKohvikType.KohvikuNimi = cafe.Name;
                uusKohvikType.Kohviku_ID = cafe.Kohvik_ID;
                uusKohvikType.Kirjeldus = cafe.Kirjeldus;
                uusList.Add(uusKohvikType);
            }
            kont.Dispose();
            LisaParingAB(rakenduseNimi, "KohvikuteNimekiri");
            return uusList;
        }

        /// <summary>
        /// Tagastab kõik kaubad tabelist Kaup
        /// </summary>
        /// <returns>kõik kaubad tabelist Kaup</returns>
        public List<KaupType> AnnaKaubad(String rakenduseNimi)
        {
            LinqtoSqlDataContext cont = new LinqtoSqlDataContext();
            List<KaupType> kaubaList = new List<KaupType>();
            var kaubad = (from x in cont.Kaups
                          select new { x.Kaup_ID, x.Nimetus }).ToList();
            foreach (var kaup in kaubad)
            {
                kaubaList.Add(new KaupType() { KaupID = kaup.Kaup_ID, Nimetus = kaup.Nimetus });
            }
            cont.Dispose();
            LisaParingAB(rakenduseNimi, "AnnaKaubad");
            return kaubaList;
        }

        /// <summary>
        /// Lisab kauba kaupade nimekirja
        /// </summary>
        /// <param name="nimetus">kauba nimi</param>
        /// <param name="rakenduseNimi">rakenduse nimi</param>
        /// <returns>kauba ID</returns>
        public int? LisaKaup(string nimetus, String rakenduseNimi)
        {
            int? id = null;
            LinqtoSqlDataContext cont = new LinqtoSqlDataContext();
            Kaup kaup = new Kaup() { Nimetus = nimetus };
            cont.Kaups.InsertOnSubmit(kaup);
            try {
                cont.SubmitChanges();
                id = kaup.Kaup_ID;
            }
            catch { id = null; }
            LisaParingAB(rakenduseNimi, "LisaKaup");
            return id;
        }

        /// <summary>
        /// Kohviku kommentaaride arv
        /// </summary>
        /// <param name="kId">kohviku ID</param>
        /// <returns>kohviku kommentaaride arv</returns>
        public int KohvikuKommentaarideArv(int kId, String rakenduseNimi)
        {
            LinqtoSqlDataContext kont = new LinqtoSqlDataContext();
            int count = (from t1 in kont.Kohviku_Kommentaars
                         where t1.Kohvik_ID == kId
                         select t1.Kohviku_Kommentaar_ID).Count();
            kont.Dispose();
            LisaParingAB(rakenduseNimi, "KohvikuKommentaarideArv");
            return count;
        //test
            //return 1000;
        }

        /// <summary>
        /// Tagastab kommentaarid lehtede kaupa
        /// </summary>
        /// <param name="kId">kohviku ID</param>
        /// <param name="rowC">kommentaaride arv</param>
        /// <param name="page">lehe indeks</param>
        /// <returns>kommentaarid massiivina</returns>
        public GenCom[] AnnaKohvikuKommentaarid(int kId, int page, int rowC, String rakenduseNimi) //rowC -row count; sof "klass."
        {
            LinqtoSqlDataContext kont = new LinqtoSqlDataContext();
            var comms = (from t1 in kont.Kohviku_Kommentaars
                         join t2 in kont.Kasutajas on t1.Kasutaja_ID equals t2.Kasutaja_ID
                         orderby t1.Kuupaev_loomine descending
                         where (t1.Kohvik_ID == kId) && (t1.Peidetud != true)
                         select new GenCom
                         {
                             cId = t1.Kohviku_Kommentaar_ID ,
                             cUId =  ( ( t1.Kasutaja_ID != null ) && ( t1.Kasutaja_ID != 1 ) ) ? (int?)t1.Kasutaja_ID : null ,
                             uName = ( ( t1.Kasutaja_ID != null ) && ( t1.Kasutaja_ID != 1 ) ) ? t2.Nimi : t1.Kommenteerija_Nimi ,
                             dText = t1.Kommentaari_Tekst ,
                             cDate = t1.Kuupaev_loomine ,
                             mDate = t1.Kuupaev_muutmine ,
                             dDate = t1.Kuupaev_kustutamine ,
                             dValue = (ushort) ( ( t1.Hinne == null ) ? 0 : ( int ) t1.Hinne ) ,
                             dHidden = (bool) ( ( t1.Peidetud == null ) ? false : ( bool ) t1.Peidetud ) ,
                             cState = (byte) ( ( t1.Olek == null ) ? 0 : ( byte ) t1.Olek )
                         })
                         .Skip(page).Take(rowC).ToList();
            kont.Dispose();
            LisaParingAB(rakenduseNimi, "AnnaKohvikuKommentaarid");
            return comms.ToArray();
        //test
            //GenCom[] list = new GenCom[10];
            //for (int i=0;i<10;i++) {
            //    list [i]= new GenCom
            //             {
            //                 cId = i ,
            //                 cUId = null ,
            //                 uName = "anon test kasutaja "+i ,
            //                 dText = "test tekst "+i ,
            //                 cDate = DateTime.Now ,
            //                 mDate = null ,
            //                 dDate = null ,
            //                 dValue = (ushort) 5 ,
            //                 dHidden = (bool) false ,
            //                 cState = (byte) 1
            //             };}
            //return list;
        }

        /// <summary>
        /// Tagastab kommentaari
        /// </summary>
        /// <param name="cId">kommentaari id</param>
        /// <returns>kommentaar</returns>
        public GenCom AnnaKohvikuKommentaar(int cId, String rakenduseNimi)
        {
            LinqtoSqlDataContext kont = new LinqtoSqlDataContext();
            GenCom [] comm  = (from t1 in kont.Kohviku_Kommentaars
                         join t2 in kont.Kasutajas on t1.Kasutaja_ID equals t2.Kasutaja_ID
                         where t1.Kohviku_Kommentaar_ID == cId
                         select new GenCom
                         {
                             cId = t1.Kohviku_Kommentaar_ID ,
                             cUId =  ( ( t1.Kasutaja_ID != null ) && ( t1.Kasutaja_ID != 1 ) ) ? (int?)t1.Kasutaja_ID : null ,
                             uName = ( ( t1.Kasutaja_ID != null ) && ( t1.Kasutaja_ID != 1 ) ) ? t2.Nimi : t1.Kommenteerija_Nimi ,
                             dText = t1.Kommentaari_Tekst ,
                             cDate = t1.Kuupaev_loomine ,
                             mDate = t1.Kuupaev_muutmine ,
                             dDate = t1.Kuupaev_kustutamine ,
                             dValue = (ushort) t1.Hinne ,
                             dHidden = (bool) t1.Peidetud ,
                             cState = (byte) t1.Olek
                         })
                         .ToArray();
            kont.Dispose();
            LisaParingAB(rakenduseNimi, "AnnaKohvikuKommentaar");
            return comm[0];
        }

        /// <summary>
        /// Tagastab kommentaaride jaoks võimalikud hinded koos kirjeldustega
        /// </summary>
        /// <returns>võimalike hinnete ja kirjelduste objekt</returns>
        public RatCom[] AnnaKohvikuKommentaarideHinded(String rakenduseNimi)
        {
            LinqtoSqlDataContext kont = new LinqtoSqlDataContext();
            //TODO: ÕIGE SISU SIIA!!
            RatCom[] array = {
            new RatCom { rVal=0 , rDes="" } ,
            new RatCom { rVal=1 , rDes="1/5" } ,
            new RatCom { rVal=2 , rDes="2/5" } ,
            new RatCom { rVal=3 , rDes="3/5" } ,
            new RatCom { rVal=4 , rDes="4/5" } ,
            new RatCom { rVal=5 , rDes="5/5" } };
            kont.Dispose();
            LisaParingAB(rakenduseNimi, "AnnaKohvikuKommentaarideHinded");
            return (array);
        }

        /// <summary>
        /// Lisab kohviku kommentaari
        /// </summary>
        /// <param name="com">Lisatava kohviku andmed</param>
        /// <returns>õnnestumisel lisatud kohviku andmed, vastasel juhul null</returns>
        public GenCom LisaKohvikuKommentaar(EdiCom com, String rakenduseNimi)
        {
            GenCom result = null ;
            LinqtoSqlDataContext kont = new LinqtoSqlDataContext();
            Kohviku_Kommentaar kom = new Kohviku_Kommentaar
            {
                Kasutaja_ID = ( com . cUId == null ) ? 1 : com . cUId ,
                Kommenteerija_Nimi = com . uName ,
                Kommentaari_Tekst = com . dText ,
                Hinne = com . dValue ,
                Kohvik_ID = com . kId ,
                Kuupaev_loomine = DateTime . Now ,
                Kuupaev_muutmine = null ,
                Kuupaev_kustutamine = null ,
                Peidetud = false ,
                Olek = CSTA . KONTROLLIMATA 
            };
            kont.Kohviku_Kommentaars.InsertOnSubmit(kom);
            try {   kont.SubmitChanges();
                    int id = kom.Kohviku_Kommentaar_ID ;
                    result = AnnaKohvikuKommentaar(id, rakenduseNimi) ; }
            catch { result = null; }
            kont.Dispose();
            LisaParingAB(rakenduseNimi, "LisaKohvikuKommentaar");
            return (result);
        }

        /// <summary>
        /// Muudab kohviku kommentaari
        /// </summary>
        /// <param name="com">Muudetava kommentaari andmed</param>
        /// <returns>õnnestumisel muudetud kommentaari andmed, vastasel juhul null</returns>
        public GenCom MuudaKohvikuKommentaar(EdiCom com, String rakenduseNimi)
        {
            GenCom result = null ;
            LinqtoSqlDataContext kont = new LinqtoSqlDataContext();
            try {
                Kohviku_Kommentaar kom = (from t1 in kont.Kohviku_Kommentaars
                                          where t1.Kohviku_Kommentaar_ID == com . cId
                                          select t1).SingleOrDefault();
                if (kom != null) {
                    kom.Kommentaari_Tekst = com.dText ;
                    kom.Hinne = com.dValue ;
                    kom.Kuupaev_muutmine = DateTime . Now ;
                    kont.SubmitChanges();
                    int id = kom.Kohviku_Kommentaar_ID ;
                    result = AnnaKohvikuKommentaar(id, rakenduseNimi) ; } }
              catch {
                result = null ; }
            kont.Dispose();
            LisaParingAB(rakenduseNimi, "MuudaKohvikuKommentaar");
            return (result);
        }

        /// <summary>
        /// Muudab kohviku kommentaari oleku
        /// </summary>
        /// <param name="com">Muudetava kommentaari andmed</param>
        /// <returns>õnnestumisel true, vastasel juhul false</returns>
        public bool MuudaKohvikuKommentaariOlek(StaCom com, String rakenduseNimi)
        {
            bool result = true ;
            LinqtoSqlDataContext kont = new LinqtoSqlDataContext();
            try {
                Kohviku_Kommentaar kom = (from t1 in kont.Kohviku_Kommentaars
                                          where t1.Kohviku_Kommentaar_ID == com . cId
                                          select t1).SingleOrDefault();
                if (kom != null) {
                    kom.Olek = com.cState ;
                    kont.SubmitChanges(); } }
              catch {
                result = false ; }
            kont.Dispose();
            LisaParingAB(rakenduseNimi, "MuudaKohvikuKommentaariOlek");
            return (result);
        }

        /// <summary>
        /// Muudab kohviku kommentaari peidetust
        /// </summary>
        /// <param name="com">Peidetava kommentaari andmed</param>
        /// <returns>õnnestumisel true, vastasel juhul false</returns>
        public bool MuudaKohvikuKommentaariPeidetus(StaCom com, String rakenduseNimi)
        {
            bool result = true ;
            LinqtoSqlDataContext kont = new LinqtoSqlDataContext();
            try {
                Kohviku_Kommentaar kom = (from t1 in kont.Kohviku_Kommentaars
                                          where t1.Kohviku_Kommentaar_ID == com . cId
                                          select t1).SingleOrDefault();
                if (kom != null) {
                    kom.Peidetud = ( com.cState == 0 ) ? false : true ;
                    kont.SubmitChanges(); } }
              catch {
                result = false ; }
            kont.Dispose();
            LisaParingAB(rakenduseNimi, "MuudaKohvikuKommentaariPeidetus");
            return (result);
        }

        /// <summary>
        /// Tagastab kohviku ID alusel
        /// </summary>
        /// <param name="kohvikID"></param>
        /// <param name="rakenduseNimi"></param>
        /// <returns>kohvik ID alusel</returns>
        public KohvikType AnnaKohvik(int kohvikID, String rakenduseNimi)
        {
            LinqtoSqlDataContext kont = new LinqtoSqlDataContext();
            List<KohvikType> kohvik = (from x in kont.Kohviks
                                where x.Kohvik_ID == kohvikID
                                select new KohvikType 
                                { 
                                    Kohviku_ID=x.Kohvik_ID,
                                    KohvikuNimi = x.Name,
                                    Pilt = x.Pilt_asukoht,
                                    Kirjeldus = x.Kirjeldus,
                                    Kinnitatud = (bool)x.Kinnitatud
                                }).ToList();
            kont.Dispose();
            LisaParingAB(rakenduseNimi, "AnnaKohvik");
            return (kohvik.Count == 0) ? null : kohvik[0];
        }

        /// <summary>
        /// Tagastab kasutajanime kasutaja ID järgi
        /// </summary>
        /// <param name="id">kasutaja ID</param>
        /// <returns>kasutajanimi</returns>
        public string AnnaKasutajaIdJargi(int id, String rakenduseNimi)
        {
            LinqtoSqlDataContext kont = new LinqtoSqlDataContext();
            var nimed = from x in kont.Kasutajas where x.Kasutaja_ID == id select x.Nimi;
            string nimi = (nimed.Count() != 0) ? nimed.First() : "";
            kont.Dispose();
            LisaParingAB(rakenduseNimi, "AnnaKasutajaIdJargi");
            return nimi;
        }

        /// <summary>
        /// Tagastab antud kasutaja nime alusel kasutaja meiliaadressi
        /// </summary>
        /// <param name="userName">kasutaja nimi</param>
        /// <returns>antud kasutaja nime alusel kasutaja meiliaadress</returns>
        public string AnnaKasutajaMeiliAadress(string userName, String rakenduseNimi)
        {
            LinqtoSqlDataContext cont = new LinqtoSqlDataContext();
            var mails = from x in cont.Kasutajas where x.Nimi == userName select x.Email;
            string email = (mails.Count() != 0) ? mails.First() : "";
            cont.Dispose();
            LisaParingAB(rakenduseNimi, "AnnaKasutajaMeiliAadress");
            return email;
        }

        /// <summary>
        /// Autendib kasutaja, õnnestumisel tagastab kasutaja ID, ebaõnnestumisel null 
        /// </summary>
        /// <param name="uNa">kasutaja nimi </param>
        /// <param name="uPa">parool avatekstina</param>
        /// <returns>õnnestumisel kasutaja ID, ebaõnnestumisel null </returns>
        public int? AuthendiKasutaja(string uNa, string uPa, String rakenduseNimi)
        {
            int? uId = null;
            LinqtoSqlDataContext kont = new LinqtoSqlDataContext();
            uNa = uNa.ToLower();
            var hash_list = (from x in kont.Kasutajas
                             where (x.Nimi).ToLower() == uNa
                             select new { x.Kasutaja_ID, x.Parool_hash }).ToList();
            string hashDB = null;
            if (hash_list.Count == 1)
            {
                hashDB = hash_list[0].Parool_hash;
            }
            if (hashDB != null)
            {
                string hash = FormsAuthentication.HashPasswordForStoringInConfigFile(uPa, "SHA1");
                if (hash == hashDB)    //SIIA SHA-1 hash !!!
                    uId = hash_list[0].Kasutaja_ID;
            }
            kont.Dispose();
            LisaParingAB(rakenduseNimi, "AuthendiKasutaja");
            return uId;
        }

        /// <summary>
        /// Registreerib kasutaja andmebaasi ja tagastab true kui kasutaja loomine õnnestus
        /// </summary>
        /// <param name="userName">kasutaja nimi</param>
        /// <param name="pass">parool avatekstina</param>
        /// <param name="liikID">kasutaja liigi ID</param>
        /// <returns>tagastab true kui kasutaja loomine 6nnestus</returns>
        public string RegistreeriKasutaja(string userName, string pass, int liikID, String rakenduseNimi)
        {
            string result = "Kasutaja loomine õnnestus.";
            LinqtoSqlDataContext kont = new LinqtoSqlDataContext();
            if (!kont.Kasutajas.Any(user => user.Nimi == userName)) // kui sellise nimega kasutajat pole
            {
                Kasutaja kasutaja = new Kasutaja();
                kasutaja.Nimi = userName;
                kasutaja.Parool_hash = FormsAuthentication.HashPasswordForStoringInConfigFile(pass, "SHA1");
                kasutaja.Kasutaja_liik_ID = liikID;
                kont.Kasutajas.InsertOnSubmit(kasutaja);
                try { kont.SubmitChanges(); }
                catch { result = "Kasutaja loomisel tekkis probleem. Proovi uuesti."; }
            }
            else { result = "Sellise nimega kasutaja on juba olemas."; }
            kont.Dispose();
            LisaParingAB(rakenduseNimi, "RegistreeriKasutaja");
            return result;
        }

        /// <summary>
        /// Tagastab rakenduse nimed ja nende vastu tehtud päringud tänasel päeval
        /// </summary>
        /// <param name="rakenduseNimi">Rakendus, kes päringu välja kutsus</param>
        /// <returns>Rakendused ja nende vastu tehtud päringud tänasel päeval</returns>
        public Dictionary<string, long> StatistikaRakendusteKohtaTana(String rakenduseNimi)
        {
            Dictionary<string, long> statistika = new Dictionary<string, long>();
            LinqtoSqlDataContext kont = new LinqtoSqlDataContext();
            string nimi;
            long paringute_arv = 0;

            var rakendused = from x in kont.Rakendus select x;
            foreach (var rakendus in rakendused)
            {
                nimi = rakendus.Nimetus;
                var paringud = from y in kont.P2rings where (y.Rakendus_ID == rakendus.Rakendus_ID &&
                                   y.Kuupäev.Date == DateTime.Today) select y;
                foreach (var paring in paringud)
                {
                    paringute_arv += (long)paring.P2ringute_arv;
                }
                statistika.Add(nimi, paringute_arv);
                paringute_arv = 0;
            }
            LisaParingAB(rakenduseNimi, "StatistikaRakendusteKohtaTana");
            return statistika;
        }

        /// <summary>
        /// Tagastab rakenduse nimed ja nende vastu tehtud päringud viimase nädala jooksul
        /// </summary>
        /// <param name="rakenduseNimi">Rakendus, kes päringu välja kutsus</param>
        /// <returns>Rakendused ja nende vastu tehtud päringud</returns>
        public Dictionary<string, long> StatistikaRakendusteKohtaViimaneNadal(String rakenduseNimi)
        {
            Dictionary<string, long> statistika = new Dictionary<string, long>();
            LinqtoSqlDataContext kont = new LinqtoSqlDataContext();
            string nimi;
            long paringute_arv = 0;

            var rakendused = from x in kont.Rakendus select x;
            foreach (var rakendus in rakendused)
            {
                nimi = rakendus.Nimetus;
                DateTime today = DateTime.Today;
                DateTime today_minus_1 = today.AddDays(-1);
                DateTime today_minus_2 = today.AddDays(-2);
                DateTime today_minus_3 = today.AddDays(-3);
                DateTime today_minus_4 = today.AddDays(-4);
                DateTime today_minus_5 = today.AddDays(-5);
                DateTime today_minus_6 = today.AddDays(-6);
                var paringud = from y in kont.P2rings
                               where (y.Rakendus_ID == rakendus.Rakendus_ID &&
                                   (y.Kuupäev == today || y.Kuupäev == today_minus_1 ||
                                   y.Kuupäev == today_minus_2 || y.Kuupäev == today_minus_3 ||
                                   y.Kuupäev == today_minus_4 || y.Kuupäev == today_minus_5 ||
                                   y.Kuupäev == today_minus_6))
                               select y;
                foreach (var paring in paringud)
                {
                    paringute_arv += (long)paring.P2ringute_arv;
                }
                statistika.Add(nimi, paringute_arv);
                paringute_arv = 0;
            }
            LisaParingAB(rakenduseNimi, "StatistikaRakendusteKohtaViimaneNadalal");
            return statistika;
        }

        /// <summary>
        /// Tagastab rakenduse nimed ja nende vastu tehtud päringud selle kuu jooksul
        /// </summary>
        /// <param name="rakenduseNimi">Rakendus, kes päringu välja kutsus</param>
        /// <returns>Rakendused ja nende vastu tehtud päringud</returns>
        public Dictionary<string, long> StatistikaRakendusteKohtaSellelKuul(String rakenduseNimi) 
        {
            Dictionary<string, long> statistika = new Dictionary<string, long>();
            LinqtoSqlDataContext kont = new LinqtoSqlDataContext();
            string nimi;
            long paringute_arv = 0;

            var rakendused = from x in kont.Rakendus select x;
            foreach (var rakendus in rakendused)
            {
                nimi = rakendus.Nimetus;
                var paringud = from y in kont.P2rings
                               where (y.Rakendus_ID == rakendus.Rakendus_ID &&
                                   (y.Kuupäev.Month == DateTime.Today.Month && 
                                   y.Kuupäev.Year == DateTime.Today.Year))
                               select y;
                foreach (var paring in paringud)
                {
                    paringute_arv += (long)paring.P2ringute_arv;
                }
                statistika.Add(nimi, paringute_arv);
                paringute_arv = 0;
            }
            LisaParingAB(rakenduseNimi, "StatistikaRakendusteKohtaSellelKuul");
            return statistika;
        }


        /// <summary>
        /// Tagastab rakenduse nimed ja nende vastu tehtud päringud kogu aja vältel
        /// </summary>
        /// <param name="rakenduseNimi">Rakendus, kes päringu välja kutsus</param>
        /// <returns>Rakendused ja nende vastu tehtud päringud</returns>
        public Dictionary<string, long> StatistikaRakendusteKohtaKokku(String rakenduseNimi)
        {
            Dictionary<string, long> statistika = new Dictionary<string, long>();
            LinqtoSqlDataContext kont = new LinqtoSqlDataContext();
            string nimi;
            long paringute_arv = 0;

            var rakendused = from x in kont.Rakendus select x;
            foreach (var rakendus in rakendused)
            {
                nimi = rakendus.Nimetus;
                var paringud = from y in kont.P2rings where y.Rakendus_ID == rakendus.Rakendus_ID select y;
                foreach (var paring in paringud)
                {
                    paringute_arv += (long)paring.P2ringute_arv;
                }
                statistika.Add(nimi, paringute_arv);
                paringute_arv = 0;
            }
            LisaParingAB(rakenduseNimi, "StatistikaRakendusteKohtaKokku");
            return statistika;
        }

        /// <summary>
        /// Meetod leiab tänase päeva jooksul kasutatud meetodid ja paringute arvu
        /// </summary>
        /// <param name="rakenduseNimi">Päringu teinud rakenduse nimi</param>
        /// <returns>Andmekogumi päringute nimedega ja kasutatud kordadega</returns>
        public Dictionary<string, long> StatistikaMeetoditeKohtaTana(String rakenduseNimi)
        {
            Dictionary<string, long> statistika = new Dictionary<string, long>();
            LinqtoSqlDataContext kont = new LinqtoSqlDataContext();
            string nimi;
            long paringute_arv = 0;

            var paringud = from y in kont.P2rings
                           where y.Kuupäev.Date == DateTime.Today
                           group y by y.Meetod into g
                           select new { Meetod = g.Key, Paringuid = g.Sum(p => p.P2ringute_arv) };
            foreach (var paring in paringud)
            {
                nimi = paring.Meetod;
                paringute_arv = (long)paring.Paringuid;
                statistika.Add(nimi, paringute_arv);

            }            
            LisaParingAB(rakenduseNimi, "StatistikaMeetoditeKohtaTana");
            return statistika;
        }

        /// <summary>
        /// Meetod leiab viimase nädala jooksul kasutatud meetodid ja paringute arvu
        /// </summary>
        /// <param name="rakenduseNimi">Päringu teinud rakenduse nimi</param>
        /// <returns>Andmekogumi päringute nimedega ja kasutatud kordadega</returns>
        public Dictionary<string, long> StatistikaMeetoditeKohtaViimaneNadal(String rakenduseNimi)
        {
            Dictionary<string, long> statistika = new Dictionary<string, long>();
            LinqtoSqlDataContext kont = new LinqtoSqlDataContext();
            string nimi;
            long paringute_arv = 0;
            DateTime today = DateTime.Today;
                DateTime today_minus_1 = today.AddDays(-1);
                DateTime today_minus_2 = today.AddDays(-2);
                DateTime today_minus_3 = today.AddDays(-3);
                DateTime today_minus_4 = today.AddDays(-4);
                DateTime today_minus_5 = today.AddDays(-5);
                DateTime today_minus_6 = today.AddDays(-6);

            var paringud = from y in kont.P2rings where (y.Kuupäev == today || y.Kuupäev == today_minus_1 ||
                                   y.Kuupäev == today_minus_2 || y.Kuupäev == today_minus_3 ||
                                   y.Kuupäev == today_minus_4 || y.Kuupäev == today_minus_5 ||
                                   y.Kuupäev == today_minus_6) group y by y.Meetod into g 
                                   select new { Meetod = g.Key, Paringuid = g.Sum( p => p.P2ringute_arv)};
            foreach (var paring in paringud)
            {
                nimi = paring.Meetod;
                paringute_arv = (long)paring.Paringuid;
                statistika.Add(nimi, paringute_arv);

            }
            LisaParingAB(rakenduseNimi, "StatistikaMeetoditeKohtaViimaneNadalal");
            return statistika;
        }

        /// <summary>
        /// Meetod leiab kuu jooksul kasutatud meetodid ja paringute arvu
        /// </summary>
        /// <param name="rakenduseNimi">Päringu teinud rakenduse nimi</param>
        /// <returns>Andmekogumi päringute nimedega ja kasutatud kordadega</returns>
        public Dictionary<string, long> StatistikaMeetoditeKohtaSellelKuul(String rakenduseNimi)
        {
            Dictionary<string, long> statistika = new Dictionary<string, long>();
            LinqtoSqlDataContext kont = new LinqtoSqlDataContext();
            string nimi;
            long paringute_arv = 0;
            DateTime today = DateTime.Today;

            var paringud = from y in kont.P2rings
                           where (y.Kuupäev.Month == today.Month && y.Kuupäev.Year == today.Year)
                           group y by y.Meetod into g
                           select new { Meetod = g.Key, Paringuid = g.Sum(p => p.P2ringute_arv) };
            foreach (var paring in paringud)
            {
                nimi = paring.Meetod;
                paringute_arv = (long)paring.Paringuid;
                statistika.Add(nimi, paringute_arv);

            }
            LisaParingAB(rakenduseNimi, "StatistikaMeetoditeKohtaSellelKuul");
            return statistika;
        }

        /// <summary>
        /// Meetod leiab kogu aja vältel kasutatud meetodid ja paringute arvu
        /// </summary>
        /// <param name="rakenduseNimi">Päringu teinud rakenduse nimi</param>
        /// <returns>Andmekogumi päringute nimedega ja kasutatud kordadega</returns>
        public Dictionary<string, long> StatistikaMeetoditeKohtaKokku(String rakenduseNimi)
        {
            Dictionary<string, long> statistika = new Dictionary<string, long>();
            LinqtoSqlDataContext kont = new LinqtoSqlDataContext();
            string nimi;
            long paringute_arv = 0;
            DateTime today = DateTime.Today;

            var paringud = from y in kont.P2rings
                           group y by y.Meetod into g
                           select new { Meetod = g.Key, Paringuid = g.Sum(p => p.P2ringute_arv) };
            foreach (var paring in paringud)
            {
                nimi = paring.Meetod;
                paringute_arv = (long)paring.Paringuid;
                statistika.Add(nimi, paringute_arv);

            }
            LisaParingAB(rakenduseNimi, "StatistikaMeetoditeKohtaKokku");
            return statistika;
        }

        

        /// <summary>
        /// Lisab andmebaasi infot päringute kohta, et hiljem sellest statistikat saaks
        /// </summary>
        /// <param name="rakendus">Rakenduse kood, kes päringu tegi</param>
        /// <param name="paringuNimi">Päringu nimi, mida kutsuti välja</param>
        public void LisaParingAB(string rakendus, string paringuNimi)
        {
            LinqtoSqlDataContext kont = new LinqtoSqlDataContext();
            int rakenduse_ID = 0;
            var kasutatavRakendus = from x in kont.Rakendus where x.Rakenduse_v6ti == rakendus select x;
            foreach (var item in kasutatavRakendus)
            {
                rakenduse_ID = item.Rakendus_ID;
            }
            var query = from x in kont.P2rings 
                        where (x.Rakendus_ID == rakenduse_ID && x.Meetod == paringuNimi && x.Kuupäev == DateTime.Today) 
                        select x;
            if (query.Count() == 0)
            {
                kont.P2rings.InsertOnSubmit(new P2ring()
                {
                    Rakendus_ID = rakenduse_ID,
                    Meetod = paringuNimi,
                    Kuupäev = DateTime.Today,
                    P2ringute_arv = 1
                });
            }
            else
            {
                foreach (var item in query) item.P2ringute_arv ++;
            }
            kont.SubmitChanges();
            kont.Dispose();
        }

        /// <summary>
        /// Tagastab kohviku lahetiolekuaja antud päeval
        /// </summary>
        /// <param name="kohvikuID">Kohviku ID</param>
        /// <param name="p2ev">Päev</param>
        /// <param name="rakenduseNimi">Päringu tenud rakenduse nimi</param>
        /// <returns></returns>
        public string[] KohvikuLahtiolekuAeg(int kohvikuID, string p2ev, string rakenduseNimi)
        {
            string[] lahtiolek;
            LinqtoSqlDataContext kont = new LinqtoSqlDataContext();

            var avatudAjad = from x in kont.Avatuds where (x.Kohvik_ID == kohvikuID && x.P2ev == p2ev) select x;
            lahtiolek = null;
            foreach (var avatud in avatudAjad)
            {
                lahtiolek = new string[2];
                lahtiolek[0] = avatud.Alates.ToString().Substring(0,5);
                lahtiolek[1] = avatud.Kuni.ToString().Substring(0,5);
            }
            kont.Dispose();
            LisaParingAB(rakenduseNimi, "KohvikuLahtiolekuAeg");

            return lahtiolek;
        }

        /// <summary>
        /// Annab vastava ID kohviku aadressi
        /// </summary>
        /// <param name="kohvikuID">Kohviku ID</param>
        /// <param name="rakenduseNimi">Rakenduse nimi</param>
        /// <returns></returns>
        public AadressType AnnaKohvikuAadress(int kohvikuID, string rakenduseNimi)
        {
            LinqtoSqlDataContext kont = new LinqtoSqlDataContext();

            var aadresses = from x in kont.Aadresses where x.Kohvik_ID == kohvikuID select x;

            AadressType a = new AadressType();
            foreach (var ad in aadresses)
            {
                a.Aadress_ID = ad.Aadress_ID;
                a.Kohvik_ID = (int)ad.Kohvik_ID;
                a.Linn = ad.Linn;
                a.Tanav = ad.Tanav;
                a.Maja = ad.Maja;
                a.Indeks = ad.Indeks;
            }

            kont.Dispose();
            LisaParingAB(rakenduseNimi, "AnnaKohvikuAadress");

            return a;
        }

    }
}

//MÄRKMED
//Kasutaja kustutamine: DELETE FROM Kasutaja WHERE (Kasutaja_ID = 12)
//LINQ join lihtne näide: http://www.hookedonlinq.com/JoinOperator.ashx
